home *** CD-ROM | disk | FTP | other *** search
/ Best Tools for JAVA / Best Tools for JAVA.iso / JAVA_ALL / HOTJAVA_ / HOTJAVA / CLASSSRC / BROWSER / FORMS / FORMIT~1.JAV < prev    next >
Encoding:
Text File  |  1995-08-11  |  5.9 KB  |  216 lines
  1. /*
  2.  * @(#)FormItem.java    1.12 95/03/19 Jonathan Payne
  3.  *
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19.  
  20. package browser.forms;
  21.  
  22. import browser.*;
  23. import awt.DisplayItem;
  24. import awt.NativeDisplayItem;
  25. import awt.Component;
  26.  
  27. /**
  28.  * Class FormItem is the superclass of all items that can appear in a
  29.  * html form.  FormItem is subclassed by the various types of input
  30.  * items that can appear in forms.  The responsibility of the
  31.  * subclasses is to return a String value appropriate for that item,
  32.  * and for creating the native display item that will actually
  33.  * appear in the document.
  34.  *
  35.  * @see FormTagRef
  36.  * @see InputTagRef
  37.  * @version 1.12, 19 Mar 1995
  38.  * @author Jonathan Payne
  39.  */
  40.  
  41. public class FormItem {
  42.     static int    flagBits[] = new int[256 / 32];
  43.     static {
  44.     int i;
  45.  
  46.     for (i = 0; i < flagBits.length; i++) {
  47.         flagBits[i] = -1;
  48.     }
  49.     for (i = 'a'; i <= 'z'; i++) {
  50.         clrBit(i);
  51.     }
  52.     for (i = 'A'; i <= 'Z'; i++) {
  53.         clrBit(i);
  54.     }
  55.     for (i = '0'; i <= '9'; i++) {
  56.         clrBit(i);
  57.     }
  58.     clrBit('_');
  59.     clrBit(' ');
  60.     }
  61.  
  62.     static void clrBit(int i) {
  63.     flagBits[i >> 5] &= ~(1 << (i & 31));
  64.     }
  65.  
  66.     static boolean charNeedsEncoding(int c) {
  67.     return (flagBits[c >> 5] & (1 << (c & 31))) != 0;
  68.     }
  69.  
  70.     /** This is the <INPUT> tag ref that causes this FormItem
  71.     to be created. */
  72.     protected InputTagRef    owner;
  73.  
  74.     /** This is the <FORM> tag ref in which this item appears. */
  75.     protected FormTagRef    form;
  76.  
  77.     /** The name of this input item (required). */
  78.     protected String    name;
  79.  
  80.     /** The default value of the input item (optional). */
  81.     protected String    defaultValue;
  82.  
  83.     /** The display item associated with this FormItem. */
  84.     protected DisplayItem    displayItem = null;
  85.  
  86.     /** Null constructor because we're called from new("<string>"),
  87.     for which only the null constructor may be called. */
  88.     public FormItem() {}
  89.  
  90.     public void initialize(WRFormatter f, FormTagRef form, InputTagRef thisItem) {
  91.     this.form = form;
  92.     owner = thisItem;
  93.     name = thisItem.getAttribute("name");
  94.     defaultValue = thisItem.getAttribute("value");
  95.     if (displayItem == null) {
  96.         displayItem = buildDisplayItem(f);
  97.     }
  98.     }
  99.  
  100.     /** Walks through the value string, escaping any special
  101.     characters that appear in the string. */
  102.     final String processString(String value) {
  103.     StringBuffer    buf = new StringBuffer(value.length() + 10);
  104.     int        cnt = value.length();
  105.  
  106.     for (int i = 0; --cnt >= 0; i++) {
  107.         int    c;
  108.  
  109.         c = value.charAt(i);
  110.         if (charNeedsEncoding(c)) {
  111.         buf.appendChar('%');
  112.         buf.appendChar(Character.forDigit(c >> 4, 16));
  113.         buf.appendChar(Character.forDigit(c & 0xF, 16));
  114.         } else {
  115.         if (c == ' ') {
  116.             c = '+';
  117.         }
  118.         buf.appendChar(c);
  119.         }
  120.     }
  121.     return buf.toString();
  122.     }
  123.  
  124.     protected int getIntegerAttribute(String name, int Default) {
  125.     int value;
  126.  
  127.     try {
  128.         value = Integer.parseInt(owner.getAttribute(name));
  129.     } catch (NumberFormatException e) {
  130.         value = Default;
  131.     } catch (NullPointerException e) {
  132.         value = Default;
  133.     }
  134.     return value;
  135.     }
  136.  
  137.     /**
  138.      * Gets the form string which is appropriate for including in
  139.      * the resulting form URL.  It's checked characters that need
  140.      * special encoding and processed appropriately.  Form items
  141.      * with more than one value will have to override this method to
  142.      * generate the right string.  Form items with a single value
  143.      * can pretty much leave this alone and just override
  144.      * getFormValue().
  145.      */
  146.     public String getFormString() {
  147.     String value = getFormValue();
  148.  
  149.     if (value != null) {
  150.         value = name + "=" + processString(value);
  151.     }
  152.     return value;
  153.     }
  154.  
  155.     /** Returns the display item associated with the form item. */
  156.     public DisplayItem getDisplayItem() {
  157.     return displayItem;
  158.     }
  159.     
  160.     /** Returns the FormTagRef associated with this FormItem. */
  161.     public FormTagRef getFormTagRef() {
  162.     return form;
  163.     }
  164.  
  165.     /** Returns the InputTagRef associated with this FormItem. */
  166.     public InputTagRef getTagRef() {
  167.     return owner;
  168.     }
  169.  
  170.     /**
  171.      * Returns the name of this form item, or null if one wasn't
  172.      * specified.
  173.      */
  174.     public String getName() {
  175.     return name;
  176.     }
  177.  
  178.     /**
  179.      * Returns the component associated with the NativeDisplayItem
  180.      * that was created for this FormItem.
  181.      * @exception ClassCastException when the display item created
  182.      * for this FormItem is not a NativeDisplayItem
  183.      */
  184.     public Component getComponent() {
  185.     return ((NativeDisplayItem) displayItem).getComponent();
  186.     }
  187.  
  188.     /** Resets the this FormItem to its default/initial value. */
  189.     public void reset() {
  190.     acceptStringValue(defaultValue);
  191.     }
  192.  
  193.     /** This is called when this particular form item is "activated".
  194.     E.g., we're a button and we've been pressed. */
  195.     public void execute() {}
  196.  
  197.     public abstract DisplayItem buildDisplayItem(WRFormatter f);
  198.     public abstract void acceptStringValue(String newValue);
  199.  
  200.     /**
  201.      * This is called to get the item to load any resources it needs for
  202.      * displaying and to verify its size (used only by image input items
  203.      * currently).
  204.      */
  205.     public void prime(WRFormatter f) {
  206.     }
  207.  
  208.     /**
  209.      * Return the value of this form Item, which by default is the
  210.      * defaultValue.
  211.      */
  212.     public String getFormValue() {
  213.     return defaultValue;
  214.     }
  215. }
  216.